/** 权限类型 1:接口,2:模块,3:服务 */
export enum APIType {
  接口 = 1,
  模块 = 2,
  服务 = 3
}
export const APITypeObj: ValueEnumMap<number> = new Map([
  [
    APIType.接口,
    {
      text: '接口',
      color: 'green'
    }
  ],
  [
    APIType.模块,
    {
      text: '模块',
      color: 'blue'
    }
  ],
  [
    APIType.服务,
    {
      text: '服务',
      color: 'purple'
    }
  ]
]);

/**	状态 0:不需要验证,1:需要登录,2:需要验证 */
export enum APIAuthType {
  不需要验证 = 0,
  需要登录 = 1,
  需要验证 = 2
}
export const APIAuthTypeObj: ValueEnumMap<number> = new Map([
  [
    APIAuthType.不需要验证,
    {
      text: '不需要验证',
      color: 'green'
    }
  ],
  [
    APIAuthType.需要登录,
    {
      text: '需要登录',
      color: 'blue'
    }
  ],
  [
    APIAuthType.需要验证,
    {
      text: '需要验证',
      color: 'purple'
    }
  ]
]);

/** 日志级别 1:正常,2:敏感,3:危险 */
export enum APILogLevel {
  正常 = 1,
  敏感 = 2,
  危险 = 3
}
export const APILogLevelObj: ValueEnumMap<number> = new Map([
  [
    APILogLevel.正常,
    {
      text: '正常',
      color: 'green'
    }
  ],
  [
    APILogLevel.敏感,
    {
      text: '敏感',
      color: 'blue'
    }
  ],
  [
    APILogLevel.危险,
    {
      text: '危险',
      color: 'purple'
    }
  ]
]);

/** 数据权限：0关闭，1开启 */
export enum APIDataAuthType {
  关闭 = 0,
  开启 = 1
}
export const APIDataAuthTypeObj: ValueEnumMap<number> = new Map([
  [
    APIDataAuthType.关闭,
    {
      text: '关闭',
      color: 'green'
    }
  ],
  [
    APIDataAuthType.开启,
    {
      text: '开启',
      color: 'blue'
    }
  ]
]);

/**	api类型 1普通接口 2开放接口 */
export enum APIOpenType {
  普通接口 = 1,
  开放接口 = 2
}
export const APIOpenTypeObj: ValueEnumMap<number> = new Map([
  [
    APIOpenType.普通接口,
    {
      text: '普通接口',
      color: 'green'
    }
  ],
  [
    APIOpenType.开放接口,
    {
      text: '开放接口',
      color: 'blue'
    }
  ]
]);

/** 是否开启接口限流：0关闭，1开启 */
export enum APIRateLimitType {
  关闭 = 0,
  开启 = 1
}
export const APIRateLimitTypeObj: ValueEnumMap<number> = new Map([
  [
    APIRateLimitType.关闭,
    {
      text: '关闭',
      color: 'green'
    }
  ],
  [
    APIRateLimitType.开启,
    {
      text: '开启',
      color: 'blue'
    }
  ]
]);

/**	限流类型 DEFAULT 默认类型，IP IP类型，CLUSTER 集群类型 */
export enum APIRateLimitMode {
  默认 = 'DEFAULT',
  IP = 'IP',
  集群 = 'CLUSTER'
}
export const APIRateLimitModeObj: ValueEnumMap<string> = new Map([
  [
    APIRateLimitMode.默认,
    {
      text: '默认',
      color: 'green'
    }
  ],
  [
    APIRateLimitMode.IP,
    {
      text: 'IP',
      color: 'blue'
    }
  ],
  [
    APIRateLimitMode.集群,
    {
      text: '集群',
      color: 'purple'
    }
  ]
]);

/**	是否级联 0不级联 1级联 */
export enum APICascadeType {
  不级联 = 0,
  级联 = 1
}
export const APICascadeTypeObj: ValueEnumMap<number> = new Map([
  [
    APICascadeType.不级联,
    {
      text: '不级联',
      color: 'green'
    }
  ],
  [
    APICascadeType.级联,
    {
      text: '级联',
      color: 'blue'
    }
  ]
]);

/** 修改锁定 */
export enum APILockType {
  锁定 = 0,
  不锁定 = 1
}
export const APILockTypeObj: ValueEnumMap<number> = new Map([
  [
    APILockType.锁定,
    {
      text: '未锁定',
      color: 'green'
    }
  ],
  [
    APILockType.不锁定,
    {
      text: '不锁定',
      color: 'blue'
    }
  ]
]);

/** 数据权限where值类型 */
export enum DataAuthWhereType {
  /** 值 */
  值 = 0,
  /** 参数 */
  参数 = 1,
  /** 表达式 */
  表达式 = 2
}

/** where值类型 */
export const DataAuthWhereTypeObj: ValueEnumMap<number> = new Map([
  [
    DataAuthWhereType.值,
    {
      text: '值',
      color: 'green'
    }
  ],
  [
    DataAuthWhereType.参数,
    {
      text: '参数',
      color: 'blue'
    }
  ],
  [
    DataAuthWhereType.表达式,
    {
      text: '表达式',
      color: 'purple'
    }
  ]
]);
